# part1 基础练习

"""
'''
basic -14 时间转换

问题描述
　　给定一个以秒为单位的时间t，要求用“<H>:<M>:<S>”的格式来表示这个时间。
    <H>表示时间，<M>表示分钟，而<S>表示秒，它们都是整数且没有前导的“0”。
    例如，若t=0，则应输出是“0:0:0”；若t=3661，则输出“1:1:1”。
输入格式
　　输入只有一行，是一个整数t（0<=t<=86399）。
输出格式
　　输出只有一行，是以“<H>:<M>:<S>”的格式所表示的时间，不包括引号。
样例输入   0    样例输出   0:0:0
样例输入   5436 样例输出   1:30:36
'''
t = int(input())
h = t // 3600
m = t // 60 % 60
s = t % 60
print(f'{h}:{m}:{s}')
"""

"""
'''
basic - 15 字符串对比
     
问题描述
　　给定两个仅由大写字母或小写字母组成的字符串(长度介于1到10之间)，它们之间的关系是以下4中情况之一：
　　1：两个字符串长度不等。比如 Beijing 和 Hebei
　　2：两个字符串不仅长度相等，而且相应位置上的字符完全一致(区分大小写)，比如 Beijing 和 Beijing
　　3：两个字符串长度相等，相应位置上的字符仅在不区分大小写的前提下才能达到完全一致（也就是说，它并不满足情况2）。
        比如 beijing 和 BEIjing
　　4：两个字符串长度相等，但是即使是不区分大小写也不能使这两个字符串一致。比如 Beijing 和 Nanjing
　　编程判断输入的两个字符串之间的关系属于这四类中的哪一类，给出所属的类的编号。
输入格式
　　包括两行，每行都是一个字符串
输出格式
　　仅有一个数字，表明这两个字符串的关系编号
样例输入
BEIjing
beiJing 
样例输出
3
'''
str1 = input()
str2 = input()
if len(str1) != len(str2):
    print(1)
else:
    if str1 == str2:
        print(2)
    else:
        str1 = str1.upper()
        str2 = str2.upper()
        if str1 == str2:
            print(3)
        else:
            print(4)
"""

"""
'''
basic -16  分解质因数
     
问题描述
　　求出区间[a,b]中所有整数的质因数分解。
输入格式
　　输入两个整数a，b。
输出格式
　　每行输出一个数的分解，形如k=a1*a2*a3...(a1<=a2<=a3...，k也是从小到大的)(具体可看样例)
样例输入
3 10
样例输出
3=3
4=2*2
5=5
6=2*3
7=7
8=2*2*2
9=3*3
10=2*5
提示
　　先筛出所有素数，然后再分解。
'''
# 运行超时
# a, b = map(int, input().split())
# def is_sushu(n):
#     for i in range(2, n):
#         if n % i == 0:
#             return False  # 不是素数
#     return True  # 是素数
#
#
# for i in range(a, b+1):  # range(a, b)函数会生成从a开始到b-1的整数序列。
#     if is_sushu(i):
#         print(i, '=', i, sep='')  # 如果是素数，则等于它本身
#         # sep -- 用来间隔多个对象，默认值是一个空格。
#         # end -- 用来设定以什么结尾。默认值是换行符\n。
#     else:
#         print(i, '=', sep='', end='')
#         temp = i
#         j = 2
#         while j < i:
#             if temp % j == 0:  # 分解质因数，从j=2开始除,直到对i取余不为0时，才j += 1，保证每个j出现最多
#                 print(j, end='')
#                 temp = temp // j
#                 if temp != 1:
#                     print('*', end='')
#             else:
#                 j = j + 1
#         print()


# 改进
a, b = list(map(int, input().split()))
result = {}  # 空字典result，用于存储每个数字的质因数分解结果

# 找到数字n的质因数分解
def sushu(res, n, result):
    for i in range(2, n + 1):  # * 循环从2开始，尝试找到`n`的因子。
        if n % i == 0:
            res += str(i)  # * 如果找到了因子`i`，则将`i`添加到结果字符串`res`中。
            n = n // i  # * 用`n`除以`i`，然后检查`n`是否已经是1或其他已知的结果。
            if n == 1:  # * 如果`n`已经是1，返回结果字符串。
                return res
            elif n in result.keys():  # * 如果`n`是已知的结果，将已知的结果添加到结果字符串并返回。
                res += '*'
                res += result[n]
                return res
            else:  # * 否则，递归调用`sushu`函数。
                res += '*'
                return sushu(res, n, result)


# 对于区间[a, b]内的每个数字，调用sushu函数进行质因数分解，并将结果存储在result字典中。
for num in range(a, b + 1):
    res = ''  # 存储分解质因数的式子
    result[num] = sushu(res, num, result)

for k, v in result.items():  # result.items() 返回一个字典中所有键-值对的列表。
    s = str(k) + '=' + str(v)
    print(s)
"""

'''
basic -17  矩阵乘法

问题描述
　　给定一个N阶矩阵A，输出A的M次幂（M是非负整数）
　　例如：
　　A =
　　1 2
　　3 4
　　A的2次幂
　　7 10
　　15 22
输入格式
　　第一行是一个正整数N、M（1<=N<=30, 0<=M<=5），表示矩阵A的阶数和要求的幂数
　　接下来N行，每行N个绝对值不超过10的非负整数，描述矩阵A的值
输出格式
　　输出共N行，每行N个整数，表示A的M次幂所对应的矩阵。相邻的数之间用一个空格隔开
样例输入
2 2
1 2
3 4
样例输出
7 10
15 22
'''


# 部分正确
# m, n = map(int, input().split())
# b = []
# # 通过循环输入m行的整数，每行的整数通过map(int,input().split())转换为列表，并将这些列表添加到b中。
# for i in range(m):
#     list1 = list(map(int,input().split()))
#     b.append(list1)
# c = b.copy()
# # print(c) # [[1, 2], [3, 4]]
#
# # A和B，分别表示两个矩阵。
# # 在函数内部，使用嵌套的循环来计算两个矩阵的乘积，并将结果保存在一个新的二维列表x中。
# def matrix(A, B):
#     x = [[0]*m for _ in range(m)] # 它用于生成一个二维列表。
#                                 # 每次循环都会创建一个新的子列表，其长度为m并且所有元素都是0。
#     for i in range(len(A)): #对于一个矩阵而言，len(a)将返回矩阵的行数。3*4的矩阵有3行，因此len(a)的结果为3。
#         for j in range(len(B[0])):# 如果a是一个3*4的矩阵，那么len(a[0])的结果将是4。
#             # 这是因为a[0]表示矩阵a的第一行，而len(a[0])表示第一行的长度，即列数。
#             # 在这种情况下，3*4的矩阵有4列，因此len(a[0])的结果为4。
#             for k in range(len(B)):
#                 x[i][j] += A[i][k] * B[k][j]
#     return x
# # print(matrix(b,c)) # [[7, 10], [15, 22]]
# # # 多次调用，每次将b和c作为参数传递给函数，并将返回的结果赋值给a。以便下一次循环使用。
# # for w in range(n-1):
# #     a = matrix(b, c)
# #     c = c
# #     b = a
# # 最后的两个嵌套循环用于打印矩阵b的元素。
# # 每次循环打印一行元素，通过在每个元素后面添加空格来实现。
# for i in range(m):
#     for j in range(m):
#         print(b[i][j], end=' ')
#     print()


m, n = map(int, input().split())
b = []
for i in range(m):
    list1 = list(map(int, input().split()))
    b.append(list1)
c = b.copy()
def matrix(x, y):
    z = [[0]*m for _ in range(m)]
    for i in range(len(x)): #第一个矩阵的行
        for j in range(len(y[0])): # 第二个矩阵的列
            for k in range(len(y)): # 第二个矩阵的行 = 第一个举证的列
                z[i][j] += (x[i][k] * y[k][j])
    return z

# 计算0次方的结果
if n == 0:
    for i in range(m):
        for j in range(m):
            if i == j:
                print(1, end=' ')
            else:
                print(0, end=' ')
        print()
else:
    for _ in range(n-1):
        a = matrix(b, c)
        c = c  # 如3次方，c为一次
        b = a  # a为刚计算的二次，只需要将（二次，一次）出来的结果为三次
    for i in range(m):
        for j in range(m):
            print(b[i][j], end=' ')
        print()





# def multi(r_1, s_1, r_2, s_2):  # 矩阵乘法函数
#     # r_1：第一个矩阵的值。  s_1：第一个矩阵的形状（行数和列数）。
#     # r_2：第二个矩阵的值。  s_2：第二个矩阵的形状（行数和列数）。
#     if s_1[1] != s_2[0]:  # 前提
#         # 在函数中，首先判断两个矩阵是否可以相乘，即第一个矩阵的列数是否等于第二个矩阵的行数，如果不满足，则返回。
#         return
#     else:
#         # 如果两个矩阵可以相乘，函数初始化一个结果矩阵 r(最终的矩阵)，其形状为 (s_1[0], s_2[1])，
#         # 并将所有元素初始化为 0。同时，它还保存结果矩阵的形状为 s。
#         r = [[0 for _ in range(s_1[0])] for _ in range(s_2[1])]
#         s = (s_1[0], s_2[1])
#
#         # 使用三层嵌套循环计算矩阵乘积。
#         for i in range(s_1[0]):  # 外层循环遍历第一个矩阵的行，
#             for k in range(s_2[1]):  # 中间循环遍历结果矩阵的列，
#                 for j in range(s_1[1]):  # 而内层循环遍历第一个矩阵的列并计算乘积的和。
#                     r[i][k] += r_1[i][j] * r_2[j][k]
#         return r, s # 最后，函数返回计算得到的结果矩阵 r 和其形状 s。
#
#
# N, M = map(int, input().split())  # 然后读入数据并初始化，首先读入两个整数N和M，表示矩阵的大小和计算次数。
# r = [[] for _ in range(N)]  # 然后初始化一个空的矩阵r，用于保存输入的矩阵。
# # print(r) [[], []]
# for i in range(N):  # 接下来使用两重循环读入矩阵的值，将其转化为整数并保存在r中。
#     arr = input().split()
#     for j in range(N):
#         r[i].append(int(arr[j]))
# s = (N, N)  # 同时定义一个形状s为N*N，
# result, shape = r, s  # 并将结果矩阵result和形状shape初始化为r和s。
# # print(result,shape) #[[1, 2], [3, 4]] (2, 2)
#
# # 计算矩阵
# if M == 0:  # 单位矩阵,斜着的是1 (如果M为0，则表示需要计算单位矩阵，即对角线上的元素为1，其余元素为0)
#     # 初始化一个 NxN 的矩阵，并将主对角线上的元素设置为 1，其他元素设置为 0。
#     result = [[0 for _ in range(N)] for _ in range(N)]  # 创建了一个 NxN 的矩阵，其中所有的元素都被初始化为 0。
#     for i in range(N):
#         result[i][i] = 1
# else:  # 如果M不为0，则使用M-1次循环调用multi函数进行矩阵乘法计算，
#     for i in range(M - 1):
#         result, shape = multi(r, s, result, shape)  # 每次将结果保存在result中，并更新shape为当前结果矩阵的形状。
#
# # 输出矩阵
# for i in range(shape[0]):
#     for j in range(shape[1]):
#         print(result[i][j], end=' ')
#     print()
# # 最后，使用两重循环输出结果矩阵result的值。
